# # 面向对象的使用
# # 个人理解，根据其对象，提取属性（外在属性，如人的身高），行为（内在属性，具有的功能或者动作）（总：名词，动词）
# # 最后根据提取的对象属性、行为构建 类 ，最后通过 类的实例化（创建类的对象） 在计算机语言 中进行使用
# # 案例 如对象： 空调
# class KongTiao(object):
#     # 具有的外在属性：空调品牌，机身高度、宽度
#     # 内置方法 __init__ 用于 类的初始化 如属性的创建（通过形式参数创建，通过self调用进行初始化）
#     def __init__(self,name,hight,witch):
#         # self 类似于 java 中的 this 特指当前对象  在方法（函数）中缺一不可，个人理解为：属性与方法的中间人（或者 代表的是 此类 的本身）
#         # self 用于在类中 调用属性，设置属性等
#         self.name=name;
#         self.hight=hight;
#         self.witch=witch;
#     # 所具有的 功能：如 吹风
#     def ChuiFeng(self):
#         print(f"{self.name}空调开启");
#     # 内置函数 __str__ 用于 自定义 返回 类的信息 （如 此类 对外的描述，如 这是一个空调类 用于构建 空调对象）
#     # dir() 查找并获取 该类具有的 内置方法、类属性、类行为 等  非自定义，而是类 本身自己拥有的东西
#     # dir() 与 __str__ 意思差不多，都是返回 类 所具有的东西，不过 一个是python对类创建是本身赋予的，以及类本身具有的属性、行为。一个是自己定义
#     def __str__(self):
#         return "这是一个空调类KongTiao 用于构建 空调对象"
#
# kong1=KongTiao("长城","1.11","221");
# kong1.ChuiFeng()
#
# print(f"自定义的类信息__str__：{kong1.__str__()}");
# print(f"自定义的类信息__str__：{kong1}");
# # dir() 书写的方式不同，其内容不变，排序方式变了：__dir__() 类本身的属性与行为 排队第一，其余之后排; dir(类对象名); Python赋予的信息为第一
# print(f"类创建之后Python赋予的和类本身的属性与行为信息 dir()：{kong1.__dir__()}");
# print(f"类创建之后Python赋予的和类本身的属性与行为信息 dir()：{dir(kong1)}");


# 继承
# class Da(object):
#     def __init__(self,chi,he):
#         self.chi=chi;
#         self.he=he;
#     def __str__(self):
#         return(f"吃：{self.chi}，喝：{self.he}")
#     def sb(self):
#         print("是第四第四")
#
#
# class Cat(Da):
#     def __init__(self, name, age,chi,he):
#         super(Cat, self).__init__(chi,he)
#         self.name = name;
#         self.age = age;
#     def dac(self):
#         print(f"{self.name}吃:{self.chi},喝{self.age}年的：{self.he}")
#
# cat=Cat("小huang","23","小鱼干","拉菲");
# cat.dac();
# cat.sb();


# 需求：使用类属性、类方法的知识实现以下功能：
# 1. 创建一个学生类Student
# 2. 实例属性有姓名name，分数score
# 3. 每创建一个对象自动实现学生个数累加
# 类属性为：num
# 4. 实现__str__方法，打印对象时，输出：学生姓名:xxx, 考试分数:yyy
# 5. 设计一个类方法show_num，输出：班级总人数为： xxx
# 6. 创建对象，调用方法，验证结果
# 7. 示例运行结果：
# 班级总人数为： 0
# 学生姓名:张三, 考试分数:59
# 学生姓名:李四, 考试分数:88
# 学生姓名:王五, 考试分数:98
# 班级总人数为： 3

# class Student(object):
#     # 类属性    计数器功能
#     num=0;
#
#     # __init__ 内置方法 构建了 类实例化对象的 实例属性 与 类属性 是不同的 ，类属性 不通过实例创建
#     def __init__(self,name,score):  # self 中间人的作用 用于属性与行为的沟通
#         self.name=name;
#         self.score=score;
#         # 当类 实例化对象时，此内置方法就会实现，所在这里进行计数，最终计算对象个数
#         Student.num+= 1 ;  # 类属性 直接通过类调用
#
#     # 自定义 返回 类的信息
#     def __str__(self):
#         return f"学生姓名:{self.name}, 考试分数:{self.score}"
#
#
#     # 构建类方法 完成对 类所创建的对象进行 计数的输出
#     @classmethod    # 类修饰符
#     def show_num(cls):      # 类方法的参数为 cls 此代表了 此类 ；创建类实例，都会在此记录 （大体意思，具体还要看代码实现）
#         print(f"班级总人数为： {cls.num}")
#
#
# # 创建 类的实例对象
# # 类方法可直接通过类调用，同时因为类实例 是根据类构建所以也可以通过类的实例调用
# Student.show_num();
# # 创建 类的实例 填写学生姓名。分数
# zs=Student("张三","59");
# print(zs.__str__())  #  创建对象以及返回的类信息，是需要打印语句进行输出的，他们只是创建、返回并没有显示这一栏
# ls=Student("李四","88");
# print(ls.__str__())
# ww=Student("王五","98");
# print(ww.__str__())
# # 类方法调用 一般采用类调用，不需要创建类实例，减少代码
# zs.show_num()


# 需求：设计 SweetPotato 地瓜类
# 1. 地瓜有两个属性：
# 状态 state：初始状态为'生的'
# 烧烤总时间 cooked_time：初始时间为0
# 2. 实现__str__方法，打印对象，输出：地瓜状态为：xxx, 烧烤总时间为：yyy 分钟
# 3. 定义 cook 方法, 形参为 time，传入本次烧烤时间
# 1. 使用 烧烤总时间 对 本次烧烤时间 进行 累加，得到最新烧烤时间
# 2. 根据 烧烤总时间, 设置地瓜的状态：
# 0 <= 烧烤总时间 < 3 ： 生的
# 3 <= 烧烤总时间 < 6 ： 半生不熟
# 6 <= 烧烤总时间 < 8 ： 熟了
# 大于等于8 ： 烤糊了
# 4. 创建对象，调用方法，验证结果

class SweetPotato(object):
    # 状态 state：初始状态为'生的'
    state="生的";
    # 烧烤总时间 cooked_time：初始时间为0
    cooked_time=0;

    # 2. 实现__str__方法，打印对象，输出：地瓜状态为：xxx, 烧烤总时间为：yyy 分钟
    def __str__(self):
        return f"地瓜状态为：{self.state}, 烧烤总时间为：{self.cooked_time} 分钟"

    # 3. 定义 cook 方法, 形参为 time，传入本次烧烤时间
    def cook(self,time):
        # 1.使用 烧烤总时间 对 本次烧烤时间 进行 累加，得到最新烧烤时间
        SweetPotato.cooked_time+=time;
        # 2. 根据 烧烤总时间, 设置地瓜的状态：
        # 0 <= 烧烤总时间 < 3 ： 生的
        if SweetPotato.cooked_time >= 0 and SweetPotato.cooked_time <3:
            SweetPotato.state="生的";
            print(f"地瓜的状态：{SweetPotato.state}");
        # 3 <= 烧烤总时间 < 6 ： 半生不熟
        elif SweetPotato.cooked_time >= 3 and SweetPotato.cooked_time <6:
            SweetPotato.state = "半生不熟";
            print(f"地瓜的状态：{SweetPotato.state}");
        # 6 <= 烧烤总时间 < 8 ： 熟了
        elif SweetPotato.cooked_time >= 6 and SweetPotato.cooked_time <8:
            SweetPotato.state = "熟了";
            print(f"地瓜的状态：{SweetPotato.state}");
        # 大于等于8 ： 烤糊了
        elif SweetPotato.cooked_time >=8:
            SweetPotato.state = "烤糊了";
            print(f"地瓜的状态：{SweetPotato.state}");

        else:
            print("烤地瓜出现错误！")

# 4. 创建对象，调用方法，验证结果
dg=SweetPotato();
dg.cook(7);
dg.cook(7);
print(dg.__str__())